/*
  南蛮图腾
  题目描述
    自从到了南蛮之地，孔明不仅把孟获收拾的服服帖帖，而且还发现了不少少数民族的智慧，
    他发现少数民族的图腾往往有着一种分形的效果，在得到了酋长的传授后，孔明掌握了不少绘图技术，
    但唯独不会画他们的图腾，于是他找上了你的爷爷的爷爷的爷爷的爷爷 …… 帮忙，
    作为一个好孙子的孙子的孙子的孙子 ……, 你能做到吗？

    给定一个正整数 n，参考输出样例，输出图形。
  输入格式
    每个数据输入一个正整数 n，表示图腾的大小。
  输出格式
    这个大小的图腾
  输入数据 1
    2
  输出数据 1
       /\
      /__\
     /\  /\
    /__\/__\
  输入数据 2
    3
  输出数据 2
           /\
          /__\
         /\  /\
        /__\/__\
       /\      /\
      /__\    /__\
     /\  /\  /\  /\
    /__\/__\/__\/__\
  提示
    数据保证，1 ≤ n ≤ 10。
*/

#include <bits/stdc++.h>

using namespace std;

/*
  二维数组 a 用来存放 2 * 4 长方形中每个格子的字符，这些字符可以组合成一个三角形!
  其中: b[1][1] 为 2 * 4 长方形的左上角的字符
        b[2][4] 为 2 * 4 长方形的右下角的字符
*/
char b[3][5] = {{},
                {' ',' ','/','\\',' '},
                {' ','/','_','_','\\'}};
char a[1030][2050] = {};

/*
  为目标长方形赋值，长方形每个格子中的值为 2 * 4 原数据的长方形 b 格子中的值
  输入参数说明:
    d_x, d_y -- 存放目标长方形的左上角的坐标(横坐标、纵坐标)，
  说明:
    原数据存放在二维数组 b 中，其中 b[1][1] 为存放原数组的 2 * 4 长方形的左上角
    长方形的长为 4 (横坐标方向上的长度)，宽为 2 (纵坐标方向上的长度)
*/
void fz(int d_x, int d_y) {
    for (int i = 0; i <= 1; i++) {
        for (int j = 0; j <= 3; j++) {
            a[d_y + i][d_x + j] = b[1 + i][1 + j];
        }
    }
}

/*
  为目标长方形赋值，长方形每个格子中的值为原数据的长方形格子中的值
  输入参数说明:
    s_x, s_y -- 存放原数据的长方形的左上角的坐标(横坐标、纵坐标)，
    d_x, d_y -- 存放目标长方形的左上角的坐标(横坐标、纵坐标)，
    len_x -- 长方形的长(横坐标方向上的长度)
    len_y -- 长方形的宽(纵坐标方向上的长度)
*/
void copy_data(int d_x, int d_y, int s_x, int s_y, int len_x, int len_y) {
    for (int i = 0; i < len_y; i++) {
        for (int j = 0; j < len_x; j++) {
            a[d_y + i][d_x + j] = a[s_y + i][s_x + j];
        }
    }
}

/*
  使用分治的方法，对长方形格子中的每个元素进行赋值
  输入参数说明：
    x1 -- 长方形左上格子的横坐标
    y1 -- 长方形左上格子的纵坐标
    x2 -- 长方形右下格子的横坐标
    y2 -- 长方形右下格子的纵坐标
  注意: 使用分治的方法进行编码时，通常会用到递归!
*/
void f(int x1, int y1, int x2, int y2) {
    if (x2 - x1 == 4 - 1 && y2 - y1 == 2 - 1) { // 递归推出条件: 长方向横坐标方向上的长度为 4，并且纵坐标方向上的长度为 2
        fz(x1, y1);
    } else {
        int len_x = (x2 - x1 + 1) / 4;  // 表示长方形横坐标方向长度的 1/4
        int len_y = (y2 - y1 + 1) / 2;  // 表示长方形纵坐标方向长度的 1/2

        /* 将该长方形分成 5 个长方形分别进行赋值处理 */

        // 1. 对左上角的长方向进行赋值，每个格子中的字符均为 ' '
        for (int i = x1; i <= x1 + len_x; i++) {
            for (int j = y1; j < y1 + len_y; j++) {
                a[j][i] = ' ';
            }
        }

        // 2. 对右上角的长方向进行赋值，每个格子中的字符均为 ' '
        for (int i = x1 + len_x * 3; i <= x2; i++) {
            for (int j = y1; j < len_y + y1; j++) {
                a[j][i] = ' ';
            }
        }

        // 3. 对中上部分的长方形进行赋值 (递归)
        f(x1 + len_x, x2 - len_x, y1, y1 + len_y - 1);

        // 4. 对左下部分的长方形进行赋值 (将中上部分的内容拷贝对左下部分)
        //  a). 确定目标（左下）长方形的第一个格子的坐标: (x1, y1 + (y2 - y1 + 1) / 2)
        //  b). 确定原数据 (中上) 长方形的第一个格子的坐标: (x1 + len_x, y1)
        //  c). 确定长方形的长(横坐标方向上的长度): (x2 - x1 + 1) / 2
        //  d). 确定长方形的宽(纵坐标方向上的长度): (y2 - y1 + 1) / 2)
        //  e). 调用 copy_data() 函数进行赋值
        copy_data(x1, y1 + (y2 - y1 + 1) / 2,
                  x1 + len_x, y1,
                  (x2 - x1 + 1) / 2,
                  (y2 - y1 + 1) / 2);

        // 5. 对右下部分的长方形进行赋值 (将中上部分的内容拷贝对右下部分)
        //  a). 确定目标（右下）长方形的第一个格子的坐标: (x1 + (x2 - x1 + 1) / 2, y1 + (y2 - y1 + 1) / 2)
        //  b). 确定原数据 (中上) 长方形的第一个格子的坐标: (x1 + len_x, y1)
        //  c). 确定长方形的长(横坐标方向上的长度): (x2 - x1 + 1) / 2
        //  d). 确定长方形的宽(纵坐标方向上的长度): (y2 - y1 + 1) / 2)
        //  e). 调用 copy_data() 函数进行赋值
        copy_data(x1 + (x2 - x1 + 1) / 2, y1 + (y2 - y1 + 1) / 2,
                  x1 + len_x, y1,
                  (x2 - x1 + 1) / 2,
                  (y2 - y1 + 1) / 2);
    }
}

int main() {
    int n;
    cin >> n;
    int x1 = 1, y1 = 1, x2 = 4, y2 = 2;
    for (int i= 2; i <= n; i++) {
        x2 *= 2;
        y2 *= 2;
    }

    // 使用分治的方法，对长方形中的每个格子进行赋值!
    //   长方形左上角的坐标为 (1, 1)
    //   长方形右下角的坐标为 (4 * pow(2, n - 1), 2 * pow(2, n - 1))
    //     注意: 确定长方形右下角的坐标时, 最好能在草稿纸上画一下，举例弄清楚计算式!
    f(1, 1, 4 * pow(2, n - 1), 2 * pow(2, n - 1));

    // 将长方形每个格子中的字符打印出来
    for (int i = 1; i <= 2 * pow(2, n - 1); i++) {
        for (int j = 1; j <= 4 * pow(2, n - 1); j++) {
            cout << a[i][j];
        }
        cout << endl;
    }

    return 0;
}
